
# Prints like a computer
course_num= 'BAUN493'
class_size= 13
pct_A= .9
avg_score= 96.58154

#Print a charcater string
print('Course Number:', course_num)
print('Class Size:', class_size)
print('Average Class Score:', avg_score)
print('% Scored a A or better:',pct_A)

Course Number: BAUN493
Class Size: 13
Average Class Score: 96.58154
% Scored a A or better: 0.9


# Prints like English
course_num= 'BAUN493'
class_size= 13
pct_A= .9
avg_score= 96.58154

print('Course Number {0:s} has a class size of {1:d} with {2:.2%} \
scoring over an A with an Average Raw Score of {3:.2f}'.\
format(course_num, class_size, pct_A, avg_score))

Course Number BAUN493 has a class size of 13 with 90.00% scoring over an A with an Average Raw Score of 96.58

x=3


y='Hello World'


# Syntactically correct way of defining 2 variables in one line of code. Not really a great idea
x=3;y='Hello World'


x = True # True and False are case senstitve
y = False


print(type(x))

<class 'str'>


x= true

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-59-9b2be4a47841> in <module>()
----> 1 x= true

NameError: name 'true' is not defined


x=1 ; y=2.5


print(type(x))

<class 'int'>


print(type(y))

<class 'float'>


myString = "This is a test!!"


print(myString[0]) #produces 'T'
print(myString[1]) #produces 'h'
print(myString[2]) #produces 'i'
print(myString[3]) #produces 's'
print(myString[4]) #Guess what!!

T
h
i
s


print(len(myString))

16


myString[15]

'!'


print(myString)
print('================')
print('Last character: ', myString[-1])  
print('2nd last character: ',myString[-2]) 
print('3rd last character: ',myString[-3])
print('4th from last: ',myString[-4])
print('First character: ', myString[-len(myString)])

This is a test!!
================
Last character:  !
2nd last character:  !
3rd last character:  t
4th from last:  s
First character:  T


print('1. Variable myString: ', myString, x)

1. Variable myString:  This is a test!! True


print('1. Variable myString: ', myString)
print('2. Starts at 0 and prints until index 2: ',myString[0:3])
print('3. Starts at 3 and prints until index 8: ',myString[3:9])
print('4. Starts at 3 and prints until index 8, skipping every 2nd caharacter: ',myString[3:9:2])
print('5. Leaving start blank, assumes 0: ',myString[:3] )
print('6. Leaving assumes you want until the end of the string: ', myString[3:])
print('7. Leaving both ends blank reproduces the string: ', myString [ : ])
print('8. PALINDROME- reverses the string: ', myString[: : -1])

1. Variable myString:  This is a test!!
2. Starts at 0 and prints until index 2:  Thi
3. Starts at 3 and prints until index 8:  s is a
4. Starts at 3 and prints until index 8, skipping every 2nd caharacter:  si 
5. Leaving start blank, assumes 0:  Thi
6. Leaving assumes you want until the end of the string:  s is a test!!
7. Leaving both ends blank reproduces the string:  This is a test!!
8. PALINDROME- reverses the string:  !!tset a si sihT


T1 = (5,4,2,6,7)
print(T1)
print(type(T1))

T2= 5,4,2,6,7
print(T2)
print(type(T2))
x1 = (5)
print(x1)
print(type(x1))

T2= (5,) #  Tuple with only single element is defined by specifying item with comma within an optional pair of parentheses.

print(T2)
print(type(T2))

(5, 4, 2, 6, 7)
<class 'tuple'>
(5, 4, 2, 6, 7)
<class 'tuple'>
5
<class 'int'>
(5,)
<class 'tuple'>


T1= (5,4,2,6,7)
print(T1)
T1[2] = 4

(5, 4, 2, 6, 7)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-87-9bdf4fec2945> in <module>()
      1 T1= (5,4,2,6,7)
      2 print(T1)
----> 3 T1[2] = 4

TypeError: 'tuple' object does not support item assignment


T1 = [(2,3),(4,5),('b',7),(8,9)]
print(type(T1))
for t in T1:
    print (t)
    print(type(t))

<class 'list'>
(2, 3)
<class 'tuple'>
(4, 5)
<class 'tuple'>
('b', 7)
<class 'tuple'>
(8, 9)
<class 'tuple'>


T1= (2,'b',3.2,10,(4,2))
print(T1)
i1,i2,i3,i4,i5 = T1
print(i1,i2,i3,i4,i5)
print(i5)
print(type(i5))

(2, 'b', 3.2, 10, (4, 2))
2 b 3.2 10 (4, 2)
(4, 2)
<class 'tuple'>


from IPython.display import Image
Image("https://media.geeksforgeeks.org/wp-content/uploads/20191122131748/Python-logical-and-operator2.jpg")


a = 3
if a <= 5:
  print("Condition is True")

Condition is True


a = 0
print ("Another Statement")
if a == 0:
    print("I am in IF Block")
else:
    print("I am in ELSE Block")

Another Statement
I am in IF Block


var = 4900
if (var < 200 and var >= 50):
    print ("Expression value is less than 200 & greater than 50")
    if var == 150:
        print ("Which is 150")
    elif var == 100:
        print ("Which is 100")
    elif var == 50:
        print ("Which is 50")
elif var < 50:
    print ("Expression value is less than 50")
else:
    print ("Could not find true expression")

Could not find true expression


from IPython.display import Image
Image("https://media.geeksforgeeks.org/wp-content/uploads/20191101172216/for-loop-python.jpg")


n = 12
for i in range(2,n):
    print(i)


from IPython.display import Image
Image("https://media.geeksforgeeks.org/wp-content/uploads/20191101170515/while-loop.jpg")


n = 5
i = 1
while(i <= n):
    print(i)
    i = i + 1


myString

'This is a test!!'


for myVar in myString:
  # print(myVar)
  if myVar == 'T':
    print ("I found a T!")

I found a T!


for letter in 'Django':    # First Example
    if letter == 'D':
        continue
    print ('Current Letter:', letter)

Current Letter: j
Current Letter: a
Current Letter: n
Current Letter: g
Current Letter: o


for letter in 'Python':     # First Example
    if letter == 'h':
        break
    print ('Current Letter :', letter)
print ('Out of For')

Current Letter : P
Current Letter : y
Current Letter : t
Out of For


x = [1,2,3]
print(type(x))

<class 'list'>


y = [10.5,23.45,34.56,45.78]
print(y)

[10.5, 23.45, 34.56, 45.78]


z = ['q','r','s','t']
print (z)

['q', 'r', 's', 't']


x = [10,25,10,38,25]
print(x)

[10, 25, 10, 38, 25]


x = [10,25,12,38,24]
print(x[0])
print(x[3])
#print (x[5])

10
38


x = [10,25,10,38,25]
print(x[-1])

25


len(x)

5


a = []
print(a)

b=list()
print(b)

[]
[]


x = [10,25,10,38,25]
print(x[1])
x[1] = 5
print(x[1])
print(x)

25
5
[10, 5, 10, 38, 25]


a = [2,4,6]
c = list(a)
print(c)
c[0] = 10
print(c)
print(a)

[2, 4, 6]
[10, 4, 6]
[2, 4, 6]


a = [2,4,6]
b = a
print(b)
b[1] = 12
print(a ,b)

[2, 4, 6]
[2, 12, 6] [2, 12, 6]


a = [2,4,6]
b = [3,2,5]
print (a[1]==b[1])
print (a[0]==b[1])
print (a==b)

False
True
False


a = [0,1,2,3,4,5,6,7,8,9,10]
print(a[1:4])
print(a[:6])
print(a[3:])
print(a[2:8:2])
print(a[2:10:2])

[1, 2, 3]
[0, 1, 2, 3, 4, 5]
[3, 4, 5, 6, 7, 8, 9, 10]
[2, 4, 6]
[2, 4, 6, 8]


x = [[2,4,6] ,[3,2,5]]
print (x)
for i in x:
    print(i)
    for j in i :
        print(j)

#### Print individual elements for following list.
y = [[[2],[2,3,4],[6,5]] ,[[3],[2,5]]]

[[2, 4, 6], [3, 2, 5]]
[2, 4, 6]
2
4
6
[3, 2, 5]
3
2
5


from IPython.display import Image
Image("https://4.bp.blogspot.com/-uRPZqKbIGwQ/XRtgWhC6qqI/AAAAAAAAH0w/--oGnwKsnpo00GwQgH2gV3RPwHwK8uONgCLcBGAs/s1600/comprehension.PNG")


numbers = [1,2,3,4]
squares=[]
for i in numbers:
    squares.append(i**2)


print(squares)

[1, 4, 9, 16]


squares2 = [i**2 for i in numbers]
print(squares2)

[1, 4, 9, 16]


# Find common numbers from two list using for loop.

list_a = [1, 2, 3, 4]
list_b = [2, 3, 4, 5]

common_num = [a for a in list_a for b in list_b if a == b]

print(common_num) # Output: [2, 3, 4]

[2, 3, 4]


list_a = [1, 2, 3]
list_b = [2, 7]

different_num = [(a, b) for a in list_a for b in list_b if a != b]

print(different_num) # Output: [(1, 2), (1, 7), (2, 7), (3, 2), (3, 7)]

[(1, 2), (1, 7), (2, 7), (3, 2), (3, 7)]


d1 = {}
print (d1)
print(type(d1))

{}
<class 'dict'>


d2 = dict()
print (d2)

{}


d3 = {3}
print (d3) 
print (type(d3))

{3}
<class 'set'>


d1 = {'a' : 3 ,'b':4}
print (d1) 
print (type(d1))

{'a': 3, 'b': 4}
<class 'dict'>


d1['b']

4


d1 = dict([('a',3), ('b',5)])
print (d1)

{'a': 3, 'b': 5}


d2= dict([['a',3], ['b',5]])
print (d2)

{'a': 3, 'b': 5}


d3= {'result1':[23,45,60], 'result2':[34,45,67]}


d = {1:'a' , 2:'b'}
print (d)
d[5] = 'g'
print(d)

{1: 'a', 2: 'b'}
{1: 'a', 2: 'b', 5: 'g'}


d = {1:'a' , 2:'b'}
print (d)
d[1] = 'g'
print(d)

{1: 'a', 2: 'b'}
{1: 'g', 2: 'b'}


print(d[1]) # getting values using keys

g


print(d.values()) # this returns list of values

dict_values(['g', 'b'])


print(d.keys()) # this returns list of keys

dict_keys([1, 2])


print(d.items()) # this dictionary in list of tuple form

dict_items([(1, 'g'), (2, 'b')])


# Keys should always be Unique 
d = {1:'a', 1:'b'}
print (d)

{1: 'b'}


d = {1:'a', 2:'b'}
print (d)
d = {'a': 2, 'b' : 3}
print (d)

{1: 'a', 2: 'b'}
{'a': 2, 'b': 3}


d = {(1,3):'a', 1:'b'}
print (d)
d1 = {[1,3]:'a', 1:'b'}
print (d1)
# Since List is not Immutable, it cannot be used as a key

{(1, 3): 'a', 1: 'b'}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-155-19023ff5733e> in <module>()
      1 d = {(1,3):'a', 1:'b'}
      2 print (d)
----> 3 d1 = {[1,3]:'a', 1:'b'}
      4 print (d1)
      5 # Since List is not Immutable, it cannot be used as a key

TypeError: unhashable type: 'list'


def print_max(a, b):
    if a > b:
        print (a, 'is maximum')
    elif a == b:
        print (a, 'is equal to', b)
    else:
        print (a, 'is maximum')


# directly pass literal values
print_max(3, 4) # calling the function

x = 5
y = 7

# pass variables as arguments
print_max(x, y)

3 is maximum
5 is maximum


def print_max(x, y):
    '''Prints the maximum of two numbers.
       The two values must be integers.
       Input Arguments: (x,y) 2 real numbers
       Output: None
       Effect: The maximum of the 2 is printed'''
    # convert to integers, if possible
    x = int(x)
    y = int(y)
    if x > y:
        print (x, 'is maximum')
    else:
        print (y, 'is maximum')


print (print_max.__doc__)

Prints the maximum of two numbers.
       The two values must be integers.
       Input Arguments: (x,y) 2 real numbers
       Output: None
       Effect: The maximum of the 2 is printed


def say(message, times=3):
    print (message * times)
say('Hello ')
say('World ', 5)

Hello Hello Hello 
World World World World World


def say1(message='Hi ', times=3):
    print (message * times)


say1('Hello ')

Hello Hello Hello


say1('World ', 5)

World World World World World


say1()

Hi Hi Hi


########################

def say2(message='Hi ', times):
    print (message * times)

say2('Hello ')

say2('World ', 5)

  File "<ipython-input-174-efc8a6f8cac7>", line 3
    def say2(message='Hi ', times):
            ^
SyntaxError: non-default argument follows default argument


def add(x,y):
  print(x+y)


ans = add(2,3) 
print(ans)

5
None


def add2(x,y):
  z= x+y
  return(z)


ans2 = add2(2,3)
print(ans2)

5


# Python program to count the frequency of  
# elements in a list using a dictionary 
  
def CountFrequency(my_list): 
    # Creating an empty dictionary  
    freq = {} 
    for item in my_list: 
        if (item in freq): 
            freq[item] += 1
        else: 
            freq[item] = 1
  
    for key, value in freq.items(): 
        print ("% d : % d"%(key, value)) 
  
# Driver function 
if __name__ == "__main__":  
    my_list =[1, 1, 1, 5, 5, 3, 1, 3, 3, 1, 4, 4, 4, 2, 2, 2, 2] 
  
    CountFrequency(my_list)

 1 :  5
 5 :  2
 3 :  3
 4 :  3
 2 :  4


import pandas
help(pandas)

Help on package pandas:

NAME
    pandas

DESCRIPTION
    pandas - a powerful data analysis and manipulation library for Python
    =====================================================================
    
    **pandas** is a Python package providing fast, flexible, and expressive data
    structures designed to make working with "relational" or "labeled" data both
    easy and intuitive. It aims to be the fundamental high-level building block for
    doing practical, **real world** data analysis in Python. Additionally, it has
    the broader goal of becoming **the most powerful and flexible open source data
    analysis / manipulation tool available in any language**. It is already well on
    its way toward this goal.
    
    Main Features
    -------------
    Here are just a few of the things that pandas does well:
    
      - Easy handling of missing data in floating point as well as non-floating
        point data.
      - Size mutability: columns can be inserted and deleted from DataFrame and
        higher dimensional objects
      - Automatic and explicit data alignment: objects can be explicitly aligned
        to a set of labels, or the user can simply ignore the labels and let
        `Series`, `DataFrame`, etc. automatically align the data for you in
        computations.
      - Powerful, flexible group by functionality to perform split-apply-combine
        operations on data sets, for both aggregating and transforming data.
      - Make it easy to convert ragged, differently-indexed data in other Python
        and NumPy data structures into DataFrame objects.
      - Intelligent label-based slicing, fancy indexing, and subsetting of large
        data sets.
      - Intuitive merging and joining data sets.
      - Flexible reshaping and pivoting of data sets.
      - Hierarchical labeling of axes (possible to have multiple labels per tick).
      - Robust IO tools for loading data from flat files (CSV and delimited),
        Excel files, databases, and saving/loading data from the ultrafast HDF5
        format.
      - Time series-specific functionality: date range generation and frequency
        conversion, moving window statistics, date shifting and lagging.

PACKAGE CONTENTS
    _config (package)
    _libs (package)
    _testing
    _typing
    _version
    api (package)
    arrays (package)
    compat (package)
    conftest
    core (package)
    errors (package)
    io (package)
    plotting (package)
    testing
    tests (package)
    tseries (package)
    util (package)

SUBMODULES
    _hashtable
    _lib
    _tslib
    offsets

CLASSES
    builtins.object
        Panel
        SparseDataFrame
        SparseSeries
        __DatetimeSub
        __SparseArraySub
    
    class Panel(builtins.object)
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    SparseArray = class __SparseArraySub(builtins.object)
     |  Methods defined here:
     |  
     |  emit_warning(dummy=0)
     |  
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |  
     |  __new__(cls, *args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class SparseDataFrame(builtins.object)
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class SparseSeries(builtins.object)
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    datetime = class __DatetimeSub(builtins.object)
     |  Methods defined here:
     |  
     |  emit_warning(dummy=0)
     |  
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |  
     |  __new__(cls, *args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)

DATA
    IndexSlice = <pandas.core.indexing._IndexSlice object>
    NA = <NA>
    NaT = NaT
    __docformat__ = 'restructuredtext'
    __git_version__ = 'b5958ee1999e9aead1938c0bba2b674378807b3d'
    describe_option = <pandas._config.config.CallableDynamicDoc object>
    get_option = <pandas._config.config.CallableDynamicDoc object>
    np = <pandas.__numpy object>
    options = <pandas._config.config.DictWrapper object>
    reset_option = <pandas._config.config.CallableDynamicDoc object>
    set_option = <pandas._config.config.CallableDynamicDoc object>

VERSION
    1.1.5

FILE
    /usr/local/lib/python3.6/dist-packages/pandas/__init__.py

/usr/lib/python3.6/inspect.py:441: FutureWarning: The pandas.datetime class is deprecated and will be removed from pandas in a future version. Import from datetime instead.
  srch_obj = srch_cls.__getattr__(cls, name)
/usr/lib/python3.6/pydoc.py:220: FutureWarning: The pandas.datetime class is deprecated and will be removed from pandas in a future version. Import from datetime instead.
  fields = getattr(object, '_fields', [])


import pandas as pd

2. Basics of Python for Data Science

2.1 Simplest of syntaxes

2.1.1. Formated Print Output

2.2. Variables and Data Types

2.2.1. Variable Declaration

2.2.2. Data Types in Python

2.2.2.1. Boolean

2.2.2.2. Number

2.2.2.3. Strings

2.2.2.3.1. Indexing Backwards

2.2.2.3.2. Grabbing Slices from a Sequence

2.2.2.4 Tuple

2.3 Control Structures

2.3.1. Conditional Statements

2.3.2. Iteration

2.3.2.1. For Loops

2.3.2.2. While Loops

2.3.2.3. Application: Easy Traversal

2.4 Python List

2.4.1. Basic Syntax

2.4.2. List Assignment and Equivalence

2.4.3. List Comparison and slicing

2.4.4. Nested list

2.4.5. List comprehension

2.5. Python Dictionaries

2.5.1 Dictionary Creation

2.5.2 Dictionary Manipulation

2.5.3 Immutable Keys

2.6. Functions and applications

2.6.1. Docstrings in function

2.6.2. Default arguement

2.6.3. Return Values

2.6.4. Dictionary Frequency table

2.7. Python Libraries

2.7.2. Important Libraries for DS in context to this course